spacepaste

Paste details

reply | raw

  1.  
  2. #define F_CPU 8000000UL
  4. #include <avr/io.h>
  5. #include <stdio.h>
  6. #include <inttypes.h>
  7. #include <stdint.h>
  8. #include <avr/pgmspace.h>
  9. #include <avr/interrupt.h>
  10. #include <util/delay.h>
  11. #include <util/atomic.h>
  12. #include <avr/wdt.h>
  14. #define BAUDRATE 9600
  16. #define NTCBETA 3380
  17. #define NTCRES 10000
  18. #define NTCFIXEDRES 10000
  20. #define ONTEMP 4.0 // °C
  21. #define OFFTEMP 2.0 // °C
  23. #define POWERONDELAY 10 // sec
  24. #define ONTIME 60 // sec
  25. #define OFFTIME 180 // sec
  28. //////////////////////////////////////////////////////////////////////////////////////////////////////////
  29. // attiny48 //
  30. // pins //
  31. // 1 : PB5 reset, ADC0 //
  32. // 2 : PB3 ADC3 / RELAY //
  33. // 3 : PB4 ADC2 / CAP //
  34. // 4 : gnd //
  35. // 5 : PB0 Mosi, AREF //
  36. // 6 : PB1 Miso / TX //
  37. // 7 : PB2 SCK, ADC1 / NTC //
  38. // 8 : VCC //
  39. // //
  40. // VCC -> 10k -> NTC -> GND //
  41. // NTC: NTSD1XH103FPB40 https://media.digikey.com/pdf/Data%20Sheets/Murata%20PDFs/NTSD1%20Spec.pdf //
  42. // Beta: 3380 //
  43. //////////////////////////////////////////////////////////////////////////////////////////////////////////
  46. #define RELAYPIN PINB
  47. #define RELAYDDR DDRB
  48. #define RELAYPORT PORTB
  49. #define RELAYBIT 3
  51. #define CAPPIN PINB
  52. #define CAPDDR DDRB
  53. #define CAPPORT PORTB
  54. #define CAPBIT 4
  56. #define NTCPIN PINB
  57. #define NTCPORT PORTB
  58. #define NTCDDR DDRB
  59. #define NTCMUX 1
  60. #define NTCBIT 2
  62. #define UARTTXPIN PINB
  63. #define UARTTXPORT PORTB
  64. #define UARTTXDDR DDRB
  65. #define UARTTXBIT 1
  67. ////////////////////////
  68. // Do not edit bellow //
  69. ////////////////////////
  72. volatile uint32_t timeSecs = 0;
  73. volatile uint32_t timeCycles = 0;
  74. volatile uint8_t status = 0;
  75. volatile uint16_t timeStatus = 0;
  76. volatile float temperature = 0.0;
  80. void usart_bitdelay() {
  81. _delay_us(1000000/BAUDRATE); // 1e6 us / baudrate
  82. }
  84. void usart_putchar(char data) {
  85. // 0 start, LSB...MSB, 1 stop
  86. uint8_t i;
  88. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  89. // start bit, 0
  90. UARTTXPORT &= ~(1 << UARTTXBIT);
  91. usart_bitdelay();
  93. // 8 data bits
  94. for (i = 0; i <= 7; i++) {
  95. if (data & 0x01) {
  96. // 1
  97. UARTTXPORT |= (1 << UARTTXBIT);
  98. } else {
  99. // 0
  100. UARTTXPORT &= ~(1 << UARTTXBIT);
  101. }
  102. data = (data >> 1);
  103. usart_bitdelay();
  104. }
  107. // stop bit, 1
  108. UARTTXPORT |= (1 << UARTTXBIT);
  109. usart_bitdelay();
  110. usart_bitdelay();
  111. }
  112. }
  114. static FILE mystdout = FDEV_SETUP_STREAM(usart_putchar, NULL, _FDEV_SETUP_WRITE);
  118. void getTemp() {
  120. }
  122. void printData() {
  123. uint32_t lsecs;
  124. uint16_t lhours;
  125. uint8_t lmins;
  127. uint8_t lstatus;
  128. uint16_t ltstatus;
  130. float ltemp;
  132. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  133. lsecs = timeSecs;
  134. lstatus = status;
  135. ltstatus = timeStatus;
  136. ltemp = temperature;
  137. };
  139. lhours = lsecs / 3600;
  140. lsecs = lsecs - (lhours * 3600);
  142. lmins = lsecs / 60;
  143. lsecs = lsecs - (lmins * 60);
  145. printf_P(PSTR("% 5d:%02d:%02d "), lhours, lmins, lsecs);
  147. //printf_P(PSTR("Temperature: % 6.1f°C "), ltemp);
  148. printf_P(PSTR("Temperature: %f°C "), ltemp);
  149. printf_P(PSTR("Status: %d "), lstatus);
  150. printf_P(PSTR("Since: %5d secs "), ltstatus);
  151. printf_P(PSTR("Reset: "));
  152. if (MCUSR & (1<<WDRF)) { printf_P(PSTR("Watchdog")); }
  153. if (MCUSR & (1<<BORF)) { printf_P(PSTR("Brownout")); }
  154. if (MCUSR & (1<<EXTRF)) { printf_P(PSTR("External")); }
  155. // if (MCUSR & (1<<PORF)) { printf_P(PSTR("Poweron")); } // removed by initialisation
  156. if ( ! ((MCUSR & (1<<WDRF)) | (MCUSR & (1<<BORF)) | (MCUSR & (1<<EXTRF)) | (MCUSR & (1<<PORF)))) {
  157. printf_P(PSTR("None"));
  158. }
  159. printf_P(PSTR("\r\n"));
  160. }
  163. void relay(uint8_t state) {
  164. if (state == 0) {
  165. RELAYPORT &= ~(1<<RELAYBIT);
  166. } else if (state == 1) {
  167. RELAYPORT |= (1<<RELAYBIT);
  168. }
  169. }
  171. uint16_t adcSample() {
  172. uint16_t adc = 0;
  173. uint8_t loop;
  175. // sample and discard first sample
  176. ADCSRA |= (1<<ADSC);
  177. while (ADCSRA & (1<<ADSC));
  179. for (loop = 0; loop < 16; loop++) {
  180. ADCSRA |= (1<<ADSC);
  181. while (ADCSRA & (1<<ADSC));
  182. adc += ADC;
  183. }
  184. return(adc / 16);
  185. }
  187. void calculateTemperature() {
  188. uint16_t adc = adcSample();
  189. float resistance;
  191. //printf_P(PSTR("ADC: % 3d Voltage: %1.2f\r\n"), adc, ((float)adc)*(5.0/1024));
  193. resistance = ((float)adc * (float)NTCFIXEDRES) / (1024-adc);
  195. //printf_P(PSTR("NTCRes: % 5f\r\n"), resistance);
  197. // 1 / T0 1/B R R25 K->C
  198. temperature = 1.0 / ( (1.0/298.15) + (1.0/(float)NTCBETA) * log(resistance / (float)NTCRES) ) - 273.15;
  199. }
  201. int main(void) {
  202. uint32_t ltime = 0;
  204. // set up watchdog timer
  205. wdt_enable(WDTO_8S);
  208. // set relay pin to output, set to off
  209. RELAYDDR |= (1<<RELAYBIT);
  210. relay(0);
  212. // set capacitor pin to input with pullup
  213. CAPDDR &= ~(1<<CAPBIT);
  214. CAPPORT |= (1<<CAPBIT);
  216. // set adc
  217. // attiny85 datasheet recommand 50-200kHz for maximum resolution
  218. // reference of 000 set to VCC, default to 000
  219. // ADMUX |= (1<<REFS0); // external ref
  220. ADMUX |= NTCMUX;
  221. // prescaller /128 = 62.5k = 111
  222. ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);
  224. // set timer0
  225. TCCR0B |= (1<<CS02) | (1<<CS00); // /1024 prescalling
  226. TIMSK |= (1<<TOIE0); // overflow interrupt enable
  228. // set uart
  229. UARTTXDDR |= (1<<UARTTXBIT);
  230. UARTTXPORT |= (1<<UARTTXBIT);
  231. stdout = &mystdout;
  234. // power on delay, for voltage and adc stabilisation
  235. _delay_ms(1000);
  236. printf_P(PSTR("\r\n"));
  237. printf_P(PSTR("Reset! \r\n"));
  239. // turn on interrupts
  240. sei();
  242. // look if the power reset flag is set, if so reset the reset sources
  243. if (MCUSR & (1<<PORF)) {
  244. MCUSR &= ~((1<<WDRF) | (1<<BORF) | (1<<EXTRF) | (1<<PORF));
  245. }
  248. // Main loop
  249. while(1) {
  250. // wait for a second to pass
  251. while (ltime == timeSecs);
  252. ltime = timeSecs;
  254. calculateTemperature();
  256. if (status == 0) {
  257. // lock out
  258. // check for cap
  259. if ((CAPPIN & (1<<CAPBIT)) && (timeStatus >= POWERONDELAY)) {
  260. // cap is discharged, release lockout
  261. status = 1;
  262. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  263. timeStatus = 0;
  264. }
  266. }
  267. } else if (status == 1) {
  268. // Off
  269. relay(0);
  270. if (temperature >= ONTEMP) {
  271. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  272. timeStatus = 0;
  273. }
  274. status = 4;
  275. }
  276. } else if (status == 2) {
  277. // Off with delay
  278. relay(0);
  279. if (timeStatus >= OFFTIME) {
  280. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  281. timeStatus = 0;
  282. }
  283. status = 1;
  284. }
  286. } else if (status == 3) {
  287. // On
  288. relay(1);
  289. if (temperature <= OFFTEMP) {
  290. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  291. timeStatus = 0;
  292. }
  293. status = 2;
  294. }
  295. } else if (status == 4) {
  296. // On with delay
  297. relay(1);
  298. if (timeStatus >= ONTIME) {
  299. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  300. timeStatus = 0;
  301. }
  302. status = 3;
  303. }
  304. }
  306. printData();
  307. wdt_reset();
  308. };
  310. return(0);
  311. }
  314. ISR(TIM0_OVF_vect) {
  315. // time keeping
  316. timeCycles += 262144; // 8 bits timer with /1024 prescaller
  317. if (timeCycles >= F_CPU) {
  318. timeCycles -= F_CPU;
  319. timeSecs++;
  320. timeStatus++;
  321. }
  323. }
  324.  
Powered by spacepaste. Paste removal.